#include "dataclass.h"
#include <fstream>
#include <QDebug>
#include <QString>

#define plot_Size 3840

//using namespace std;


//在主程序中需要做的事情：调用DataClass::findMaxMinData(int begin, int end)函数
//判断end-begin时候大于3941*2：
//若大于，maxData,minData
//若小于，maxData=minData


/* 通过调用DataClass::findMaxMinData(int begin, int end)函数；
 * 可以找到指定范围内数据的最大值和最小值数组，从而获得包络线
 * 而当begin与end之间的数据个数>3941*2的时候，进行取样处理
 * 而当begin与end之间的数据个数<3941*2的时候，将所有数据进行绘制
 *
 * ！！！这里的3940*4是可以更改的，在DataClass::findMaxMinData(int begin, int end)函数中的if语句中修改
*/


DataClass::DataClass(QObject *parent) : QObject(parent)
{

}


/*函数名称：txt2dataV
 * 函数功能：读取选取的二进制文件，然后把其中的数据存储到dataVector数组中
*/
void DataClass::txt2dataV(QString filePath){                   //这里的计算公式需要随时修改

    double canshu = 100.0;

    unsigned char data[16384];
    unsigned char data2[16384];

    int flagPitch,flagRoll;

    // 以读模式打开文件
    ifstream infile(filePath.toStdString(), ios::in | ios::binary);
    while (infile.read((char *)&data, sizeof(data))) {
        for (int i=0;i<8192;i++) {
            if (data[2*i+1]<16) {
                dataVector0.append(data[2*i+1]*256 + data[2*i]);
            }else if (data[2*i+1]<32) {
                dataVector1.append((data[2*i+1]-16)*256 + data[2*i]);
            }else if (data[2*i+1]<48) {
                dataVector2.append((data[2*i+1]-32)*256 + data[2*i]);
            }else if (data[2*i+1]<64) {
                dataVector3.append((data[2*i+1]-48)*256 + data[2*i]);
            }else if (data[2*i+1]<80) {
                dataVector4.append((data[2*i+1]-64)*256 + data[2*i]);
            }else if (data[2*i+1]<96) {
                dataVector5.append((data[2*i+1]-80)*256 + data[2*i]);
            }else if (data[2*i+1]<112) {
                dataVector6.append((data[2*i+1]-96)*256 + data[2*i]);
            }else if (data[2*i+1]<128) {
                dataVector7.append((data[2*i+1]-112)*256 + data[2*i]);
            }else if (data[2*i+1]<144) {
                dataVector8.append((data[2*i+1]-128)*256 + data[2*i]);
            }else if (data[2*i+1]<160) {
                dataVector9.append((data[2*i+1]-144)*256 + data[2*i]);
            }else if (data[2*i+1]<176) {
                dataVectorA.append((data[2*i+1]-160)*256 + data[2*i]);
            }else if (data[2*i+1]<192) {
                dataVectorB.append((data[2*i+1]-176)*256 + data[2*i]);
            }
        }
    }
    infile.close();

    //下面的代码为获得姿态文件路径
    QString ZITTXT = "ZIT.txt";
    filePath = filePath.left(filePath.size()-4)+ZITTXT;

    //读取ZIT.txt
    ifstream infile2(filePath.toStdString(), ios::in | ios::binary);
    infile2.read((char *)&data2, sizeof(data2));
    int i119=0,i13=0,iis=0;
    for (int i=0;i<16384;i++) {
        if(data2[i]==119){//&(data[i+1]+data[i+2]+data[i+3]+data[i+4]+data[i+5]+data[i+6]+data[i+7]+data[i+8]+data[i+9]+data[i+10]+data[i+11]+data[i+12])%256==data[i+13]
            i119++;
            if(data2[i+1]==13){
                i13++;
                if((data2[i+1]+data2[i+2]+data2[i+3]+data2[i+4]+data2[i+5]+data2[i+6]+data2[i+7]+
                    data2[i+8]+data2[i+9]+data2[i+10]+data2[i+11]+data2[i+12])%256==data2[i+13]){
                    iis++;
                    if(data2[i+4]/16){
                        flagPitch = -1;
                    }else {
                        flagPitch = 1;
                    }

                    if(data2[i+7]/16){
                        flagRoll = -1;
                    }else {
                        flagRoll = 1;
                    }

                    pitch.append(((data2[i+4]%16)*100+data2[i+5]/16*10+data2[i+5]%16+
                            (data2[i+6]/16*10+data2[i+6]%16)/canshu)*flagPitch);

                    roll.append(((data2[i+7]%16)*100+data2[i+8]/16*10+data2[i+8]%16+
                            (data2[i+9]/16*10+data2[i+9]%16)/canshu)*flagRoll);
                    i+=13;
                }
            }
        }
    }
    qDebug()<<"77个数="<<i119<<"0D个数="<<i13<<"校验个数="<<iis;
    // 关闭打开的文件
    infile2.close();


    //下面的代码为获得时间文件路径
    QString GPSTXT = "GPS.txt";
    filePath = filePath.left(filePath.size()-7)+GPSTXT;

    /*读取GPS.txt*/
    ifstream infile3(filePath.toStdString(), ios::in | ios::binary);
    infile3>>line;
    infile3.close();

    //初始化dataclass中的数据大小
    data0_size = dataVector0.size();data1_size = dataVector1.size();
    data2_size = dataVector2.size();data3_size = dataVector3.size();
    data4_size = dataVector4.size();data5_size = dataVector5.size();
    data6_size = dataVector6.size();data7_size = dataVector7.size();
    data8_size = dataVector8.size();data9_size = dataVector9.size();
    dataA_size = dataVectorA.size();dataB_size = dataVectorB.size();
    pitch_size = pitch.size();roll_size = roll.size();

    /*获取min_data_size*/
    //如果需要判断通道是否使用，则下面3行需要使用if语句判断是否插入data_size
    data_size.append(data0_size);data_size.append(data1_size);data_size.append(data2_size);data_size.append(data3_size);
    data_size.append(data4_size);data_size.append(data5_size);data_size.append(data6_size);data_size.append(data7_size);
    data_size.append(data8_size);data_size.append(data9_size);data_size.append(dataA_size);data_size.append(dataB_size);
    sort(data_size.begin(), data_size.end());//进行升序排序
    min_data_size = data_size.first();//取最小值

    /*获取plot_sizeFoot*/
    if(pitch_size)
        plot_sizeFoot = min_data_size/pitch_size;
    else
        plot_sizeFoot = 0;
}


/*函数名称：initializeMaxMin
 * 函数功能：初始化maxData和minData两个vector，清空所有数据
*/
void DataClass::initializeMaxMin(){//!!!!!这里的0需要修改
    //置零
    indData.clear();
    maxData0.clear();maxData1.clear();maxData2.clear();maxData3.clear();maxData4.clear();maxData5.clear();
    maxData6.clear();maxData7.clear();maxData8.clear();maxData9.clear();maxDataA.clear();maxDataB.clear();

    pitchCa.clear();
    rollCa.clear();
}

/*函数名称：findMax
 * 参数1：dataVector：进行操作的vector
 * 参数2：beginN：开始位置
 * 参数3：sizeMe：数据长度
 * 函数功能：找到并返回dataVector数组中，beginN开始的，长度为sizeMe的数据中的最大值、最小值，
 * 并存储到全局变量max、min中
*/
void DataClass::findMaxMin(QVector<int> dataVector,int beginN, int sizeMe){
    max = dataVector[beginN];
    min = dataVector[beginN];
    for (int i=beginN; i<beginN+sizeMe; i++) {
        if(dataVector[i]>max){
            max = dataVector[i];
            continue;
        }
        if(dataVector[i]<min){
            min = dataVector[i];
            continue;
        }
    }
}



/*函数名称：findMaxMinData
 * 参数1：begin：data数组中数据开始角标
 * 参数2：end：data数组中数据结束角标
 * 函数功能：处理data数组中begin到end的数据，进行分割，找到其中各个小组的最大值和最小值，
 *          并存储在maxData和minData数组中
*/
void DataClass::findMaxMinData(int begin, int end, bool *flag){

    initializeMaxMin();//清零各个vector

    int number = end-begin;
    int remain;

    if(flag[12]){
        for (int i=0;i<pitch.size();i++) {
            pitchCa.append(pitch[i]);
        }
    }
    if(flag[13]){
        for (int i=0;i<roll.size();i++) {
            rollCa.append(roll[i]);
        }
    }

    if(number>plot_Size*2){/////////////////////////////////////////////这里的当为0时的逻辑存在问题，无数据，务必解决
        //采点
        int size = number/plot_Size;
        for (int i = 0; i<plot_Size;i++) {
            if(flag[0]){
                findMaxMin(dataVector0,i*size+begin, size);
                maxData0.append(max);
            }

            if(flag[1]){
                findMaxMin(dataVector1,i*size+begin, size);
                maxData1.append(max);
            }

            if(flag[2]){
                findMaxMin(dataVector2,i*size+begin, size);
                maxData2.append(max);
            }

            if(flag[3]){
                findMaxMin(dataVector3,i*size+begin, size);
                maxData3.append(max);
            }

            if(flag[4]){
                findMaxMin(dataVector4,i*size+begin, size);
                maxData4.append(max);
            }

            if(flag[5]){
                findMaxMin(dataVector5,i*size+begin, size);
                maxData5.append(max);
            }

            if(flag[6]){
                findMaxMin(dataVector6,i*size+begin, size);
                maxData6.append(max);
            }

            if(flag[7]){
                findMaxMin(dataVector7,i*size+begin, size);
                maxData7.append(max);
            }

            if(flag[8]){
                findMaxMin(dataVector8,i*size+begin, size);
                maxData8.append(max);
            }

            if(flag[9]){
                findMaxMin(dataVector9,i*size+begin, size);
                maxData9.append(max);
            }

            if(flag[10]){
                findMaxMin(dataVectorA,i*size+begin, size);
                maxDataA.append(max);
            }

            if(flag[11]){
                findMaxMin(dataVectorB,i*size+begin, size);
                maxDataB.append(max);
            }

            indData.append(i*size+begin);
        }
        if(number>size*plot_Size){
            remain = number-size*plot_Size;

            if(flag[0]){
                findMaxMin(dataVector0,plot_Size*size+begin, remain);
                maxData0.append(max);
            }

            if(flag[1]){
                findMaxMin(dataVector1,plot_Size*size+begin, remain);
                maxData1.append(max);
            }

            if(flag[2]){
                findMaxMin(dataVector2,plot_Size*size+begin, remain);
                maxData2.append(max);
            }

            if(flag[3]){
                findMaxMin(dataVector3,plot_Size*size+begin, remain);
                maxData3.append(max);
            }

            if(flag[4]){
                findMaxMin(dataVector4,plot_Size*size+begin, remain);
                maxData4.append(max);
            }

            if(flag[5]){
                findMaxMin(dataVector5,plot_Size*size+begin, remain);
                maxData5.append(max);
            }

            if(flag[6]){
                findMaxMin(dataVector6,plot_Size*size+begin, remain);
                maxData6.append(max);
            }

            if(flag[7]){
                findMaxMin(dataVector7,plot_Size*size+begin, remain);
                maxData7.append(max);
            }
            if(flag[8]){
                findMaxMin(dataVector8,plot_Size*size+begin, remain);
                maxData8.append(max);
            }

            if(flag[9]){
                findMaxMin(dataVector9,plot_Size*size+begin, remain);
                maxData9.append(max);
            }

            if(flag[10]){
                findMaxMin(dataVectorA,plot_Size*size+begin, remain);
                maxDataA.append(max);
            }

            if(flag[11]){
                findMaxMin(dataVectorB,plot_Size*size+begin, remain);
                maxDataB.append(max);
            }

            indData.append(plot_Size*size+begin);
        }
    }else{
        //直接画
        for (int in=0;in<number;in++) {
            if(flag[0]){
                maxData0.append(dataVector0[in+begin]);
            }

            if(flag[1]){
                maxData1.append(dataVector1[in+begin]);
            }

            if(flag[2]){
                maxData2.append(dataVector2[in+begin]);
            }

            if(flag[3]){
                maxData3.append(dataVector3[in+begin]);
            }

            if(flag[4]){
                maxData4.append(dataVector4[in+begin]);
            }

            if(flag[5]){
                maxData5.append(dataVector5[in+begin]);
            }

            if(flag[6]){
                maxData6.append(dataVector6[in+begin]);
            }

            if(flag[7]){
                maxData7.append(dataVector7[in+begin]);
            }

            if(flag[8]){
                maxData8.append(dataVector8[in+begin]);
            }

            if(flag[9]){
                maxData9.append(dataVector9[in+begin]);
            }

            if(flag[10]){
                maxDataA.append(dataVectorA[in+begin]);
            }

            if(flag[11]){
                maxDataB.append(dataVectorB[in+begin]);
            }

            indData.append(in+begin);
        }
    }
}
